package JDK常用类库.lambda;

import org.junit.Test;

import java.io.PrintStream;
import java.util.Comparator;
import java.util.function.BiPredicate;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Supplier;

/**
 * @author zx
 * @create 2023-08-01 22:49
 * 方法引用的使用
 * 1.使用情境：当要传递给Lambda体的操作，已经有实现的方法了(一般是JDK内置了方法)，可以使用方法引用！
 * 2.方法引用，本质上就是Lambda的表达式，而Lambda表达式作为函数式接口的实例；
 * 所以，方法引用也是函数式接口的实例。
 * 3.使用格式： 类(或对象)::方法名
 * 4.具体分为如下的三种情况：
 *   a.对象::非静态方法
 *   b.类::静态方法
 *   c.类::非静态方法
 *
 * 5.方法引用使用的要求：要求接口中的抽象方法的形参列表和返回值类型与方法引用的方法的形参列表和返回值类型相同！
 */
public class MethodRefTest {
    /**
     * 情况一：对象::实例方法
     */
    @Test
    public void test1(){
        Consumer<String> con1 = str -> System.out.println(str);
        con1.accept("南京");

        PrintStream ps = System.out;
        Consumer<String> con2 = ps::println;
        con2.accept("西安");
    }

    /**
     * 情况二：类::静态方法
     */
    @Test
    public void test2(){
        Supplier<Long> supplier1 = () -> {
            return System.currentTimeMillis();
        };
        System.out.println(supplier1.get());

        Supplier<Long> supplier2 = System::currentTimeMillis;
        System.out.println(supplier2.get());
    }

    /**
     * 情况二：类::静态方法
     */
    @Test
    public void test3(){
        Comparator<Integer> com1 = (t1,t2) -> Integer.compare(t1,t2);
        System.out.println(com1.compare(10,23));

        Comparator<Integer> com2 = Integer::compare;
        System.out.println(com2.compare(10,16));
    }
    @Test
    public void test4(){
        Function<Double,Long> func = new Function<Double, Long>() {
            @Override
            public Long apply(Double d) {
                return Math.round(d);
            }
        };
        Function<Double,Long> func1 = d -> Math.round(d);
        System.out.println(func1.apply(10.6));
        Function<Double,Long> func2 = Math::round;
        System.out.println(func2.apply(10.23));
    }

    /**
     * 情况三：类::实例方法(有难度)
     * Java中, 类名只能调用静态方法, 类名引用实例方法是用前提的, 实际是拿第一个参数作为方法的调用者
     */
    @Test
    public void test5(){
        Comparator<String> com1 = (s1,s2) -> s1.compareTo(s2);
        System.out.println(com1.compare("abc","abd"));
        Comparator<String> com2 = String::compareTo;
        System.out.println(com2.compare("abd","abm"));
    }
    @Test
    public void test6(){
        BiPredicate<String,String> pre1 = (s1,s2) -> s1.equals(s2);
        System.out.println(pre1.test("abc","abc"));
        BiPredicate<String,String> pre2 = String::equals;
        System.out.println(pre2.test("abc","abc"));
    }
}
